/*
  光荣的梦想
  题目描述
    Prince 对他在这片大陆上维护的秩序感到满意，于是决定启程离开艾泽拉斯。
    在他动身之前，Prince 决定赋予 King_Bette 最强大的能量以守护世界、保卫这里的平衡与和谐。
    在那个时代，平衡是个梦想。因为有很多奇异的物种拥有各种不稳定的能量，平衡瞬间即被打破。
    KB 决定求助于你，帮助他完成这个梦想。
    一串数列即表示一个世界的状态。平衡是指这串数列以升序排列。
    而从一串无序数列到有序数列需要通过交换数列中的元素来实现。
    KB 的能量只能交换相邻两个数字。
    他想知道他最少需要交换几次就能使数列有序。
  输入格式
    第一行为数列中数的个数 n,
    第二行为 n ≤ 10000 个数。表示当前数列的状态。
  输出格式
    输出一个整数，表示最少需要交换几次能达到平衡状态。
  输入数据 1
    4
    2 1 4 3
  输出数据 1
    2
*/

#include <bits/stdc++.h>

using namespace std;

int a[10005];  // 数组 a, 存放待排序的若干个数, 排序后的数也存放在该数组中
int b[10005];  // 临时数组
int n;
long long num = 0; // 相邻 2 个数进行交换的次数

/*
  求最少需要的相邻 2 个数进行交换次数的思路:
    1. 由于题目提到平衡指一串数列的升序排列，我们首先就会想到要进行排序!
    2. 由于使用归并算法进行排序中，归并排序中每一轮合并时，会比较左半部分和右半部分的对应下标的值,
       因此使用归并排序时，有机会顺带完成这类事情!
       进一步举例找规律，发现这个题的求解式和求逆序对完全相同!
       因此，本题的代码实现和求逆序对基本相同!
*/

/*
  函数功能:
    使用归并排序算法, 对数组 a[s] ~ a[e] 按从小到大的顺序进行排序,
    完成排序后, a[s] ~ a[e] 为从小到大的顺序。
    并且统计出最少需要交换几次能达到平衡状态的次数。
  参数说明:
     s  -- 对数组 a[] 进行排序的开始下标
     e  -- 对数组 a[] 进行排序的结束下标，其中 e >= s
  小结:
     归并排序使用了递归的方式进行编码实现!
*/
void f(int s, int e) {
    if (s == e) { // 当序列中只有 1 个数时，不需要其他排序操作，已经排好序了!
        return;
    } else {
        int mid = (s + e) / 2;

        // 1. 对数组 a 的左半部分(a[s] ~ a[mid]), 使用归并排序的方法按从小到大的顺序进行排序
        f(s, mid);

        // 2. 对数组 a 的右半部分(a[mid + 1] ~ a[e]), 使用归并排序的方法按从小到大的顺序进行排序
        f(mid + 1, e);

        // 3. 将数组 a 的左半部分和右半部进行合并, 合并成一个从小到大的有序数组，并求出逆序数
        //    实现方法:
        //      a[i] 和 a[j] 进行比较，将小的数放到 b[k];
        //        (如果 a[j] 比 a[i] 小, 那么左半部分的剩余元素个数即为本轮最少需要交换的次数!)
        //      然后将下标 i或j、k 往后移动 1 位(即+1);
        //      依次类推, 即可完成将左半部分和右半部分的合并，合并后的数存放在临时数序 b 中!
        //      最后使用数组 b 中的元素为 数组 a 中的对应元素赋值!
        int i = s;
        int j = mid + 1;
        int k = s;
        while (i <= mid && j <= e) {
            if (a[i] <= a[j]) {
                b[k++] = a[i++];
            } else {
                num += mid - i + 1; // 如果右半部分下标的值更小，则此时左半部分存在的元素个数即为本轮比这个数大的需要交换的次数！
                b[k++] = a[j++];
            }
        }
        while (i <= mid) {
            b[k++] = a[i++];
        }
        while (j <= e) {
            b[k++] = a[j++];
        }

        // 4. 使用数组 b 中的元素为数组 a 中的对应元素赋值!
        for (int i = s; i <= e; i++) {
            a[i] = b[i];
        }
    }
}

int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }

    // 使用归并排序算法, 对数组 a[1] ~ a[n] 按从小到大的顺序进行排序，并统计出需要进行的相邻2个数的交换的次数
    f(1, n);

    cout << num;

    return 0;
}